home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / clix360 / doc / udo / hm2 / haenisch.ui
Text File  |  1997-01-21  |  59KB  |  1,635 lines
  1. #-----------------------------------------------------------------
  2. # Hänisch-Modula
  3. #-----------------------------------------------------------------
  4.  
  5. !node Hänisch-Modula-2
  6.  
  7. !subtoc [html, stg]
  8.  
  9. #*****************************************************************
  10. !subnode Laufzeitfehler
  11.  
  12. Laufzeitfehler führen zu sogenannten Exceptions des Prozessors. Das HM2 
  13. Laufzeitsystem verändert normalerweise keine Systemvektoren, sodaß ein 
  14. Laufzeitfehler ohne weitere Maßnahmen zum Absturz des Programms führt. 
  15. Die Kontrolle darüber, was bei einem Laufzeitfehler geschehen soll, 
  16. liegt voll beim Programmierer. Der einfachste Weg, auf Laufzeitfehler zu 
  17. reagieren, ist der Import des Moduls [Rts]. Ist dieses Modul zum 
  18. Programm gelinkt, so wird das Programm per Default bei einem 
  19. Laufzeitfehler terminiert (wobei die Terminierungskette abgearbeitet 
  20. wird). Durch Installation einer geeigneten Prozedur sind mit diesem 
  21. Modul aber auch andere Reaktionen auf Laufzeitfehler möglich.
  22.  
  23. Falls das Programm unter dem Runtime Debugger (RTD) gestartet wird, 
  24. werden selbstverständlich alle Exceptions abgefangen und Laufzeitfehler 
  25. im Klartext ausgegeben, auch wenn das Modul Rts nicht gelinkt ist.
  26.  
  27. Wird das Programm von (!PRG) aus als Testprogramm gestartet, so besteht 
  28. bei einem Laufzeitfehler die Möglichkeit, einen Dump zu schreiben, der 
  29. dann mit dem Post Mortem Debugger (PMD) analysiert werden kann. Dazu muß 
  30. in (!PRG) die Option 'Dump-Option für TEST-Programm' aktiviert sein und 
  31. das Modul Rts muß zum Testprogramm gelinkt sein.
  32.  
  33. #*****************************************************************
  34. !subnode Bedingte Compilierung
  35.  
  36. Bedingte Compilierung ermöglicht es, Teile des Sourcetextes abhängig von 
  37. einer Bedingung zu compilieren. Das ist z.B. praktisch, um von einem 
  38. Programm verschiedene Versionen zu erzeugen (z.B. eine Version mit 
  39. eingschränktem Funtionsumfang oder eine Version mit Debug-Ausgaben). 
  40. Dazu wird der betreffende Abschnitt des Sourcetextes in 
  41. Kommentarklammern gesetzt und durch '$? <konstanter boolscher Ausdruck> 
  42. :' eingeleitet. Beispiel:
  43.  
  44. !begin_verbatim
  45.     CONST
  46.          compile = TRUE;
  47.     
  48.     BEGIN
  49.     (* $? compile:
  50.             (* Dieser Bereich wird nur dann übersetzt, wenn compile
  51.                  den Wert TRUE hat *) 
  52.             WriteString ('Die Konstante compile hat den Wert TRUE');
  53.     *) 
  54. !end_verbatim
  55.  
  56. Falls der boolsche Ausdruck den Wert FALSE hat, so wird der geklammerte 
  57. Bereich als Kommentar angesehen.
  58.  
  59. Um verschiedene Versionen eines Programms zu verwalten, bietet sich die 
  60. Verwendung der Makevariable FLAG an (der Wert dieser Variable kann im 
  61. Optionendialog bei Flag eingestellt werden). Damit kann in Abhängigkeit 
  62. von SYSTEM.FLAG eine Version definiert werden. Beispiel:
  63.  
  64.  
  65. !begin_verbatim
  66.     DEFINITION MODULE Base;
  67.  
  68.     IMPORT SYSTEM;
  69.  
  70.     CONST
  71.         Full = SYSTEM.FLAG = 0;
  72.         Demo = SYSTEM.FLAG = 1;
  73. !end_verbatim
  74.  
  75. Je nach Wert der Makevariablen FLAG wird nun beim Compileren des 
  76. Definitionsmoduls der Wert von Full und Demo festgelegt. In Abhängigkeit 
  77. von diesem Wert können in anderen Modulen mittels bedingter Compilierung 
  78. Teile übersetzt werden oder nicht.
  79.  
  80. !begin_verbatim
  81.     IMPORT Base;
  82.  
  83.     (*$? Base.Demo:
  84.             WriteString ('Dies ist die Demoversion');
  85.     *) 
  86.     (*$? Base.Full:
  87.             WriteString ('Dies ist die Vollversion');
  88.     *) 
  89. !end_verbatim
  90.  
  91.  
  92.  
  93. Neben der bedingten Compilierung abhängig von einem boolschen Ausdruck 
  94. gibt es auch die bedingte Compilierung abhängig von einer Option. Dazu 
  95. wird der Bereich durch '$! X±:' eingeleitet, wobei X für eine beliebige 
  96. Compiler-Option steht (nicht nur Großbuchstabe) und '±' für '+' oder 
  97. '-'. Beispiel:
  98.  
  99. !begin_verbatim
  100.     (* $!2+:
  101.         (* Dieser Bereich wird übersetzt,
  102.              falls die Option 2 aktiviert ist 
  103.         WriteString ('Das Programm läuft nur auf MC68020/30/40');
  104.     
  105.     (* $!2-:
  106.         (* Dieser Bereich wird übersetzt,
  107.              falls die Option 2 nicht aktiviert ist 
  108.         WriteString ('Das Programm läuft auch auf einem MC68000');
  109.     
  110. !end_verbatim
  111.  
  112. #*****************************************************************
  113. !subnode Compiler-Optionen
  114.  
  115. Die Compiler-Optionen, auch Schalter genannt, beeinflussen das Verhalten 
  116. des Compilers in Bezug auf Überprüfungen und Codeerzeugung.
  117.  
  118. Sie können global im Optionen-Dialog oder für einzelne Module direkt im 
  119. Source-Text gesetzt werden. Im Source-Text können allerdings nur die 
  120. Optionen mit einem Großbuchstaben gesetzt werden. Sie stehen in 
  121. Kommentaren und werden durch ein '$'-Zeichen eingeleitet, gefolgt von 
  122. einem Großbuchstaben und '+', '-' oder '=':
  123.  
  124. !stg @autorefoff
  125. !begin_itemize
  126. !item (*$X+*) aktiviert die Option X,
  127. !item (*$X-*) deaktiviert sie
  128. !item (*$X=*) restauriert den Zustand vor der letzten Änderung.
  129. !end_itemize
  130. !stg @autorefon
  131.  
  132. Um eine Option auf einen bestimmten Bereich (z.B. eine Prozedur) zu 
  133. beschränken, sollte man am Ende dieses Bereichs die Option mittels der 
  134. '='-Variante auf den alten Zustand zurücksetzen. Diese Zeichenfolgen ($, 
  135. Großbuchstabe, +/-/=) werden an beliebiger Stelle innerhalb eines 
  136. Kommentars als Option interpretiert. Es können also auch mehrere 
  137. Optionen in einem Kommentar gesetzt werden und die Kommentarklammern 
  138. müssen die Optionen nicht direkt umschließen:
  139.  
  140. !stg @autorefoff
  141. Beispiel: (* $K+ $B+ $E+$D- *) 
  142. !stg @autorefon
  143.  
  144. In geschachtelten Kommentaren werden sie jedoch nicht interpretiert; sie 
  145. können also auch auskommentiert werden.
  146.  
  147. !subsubtoc [stg, html]
  148.  
  149. #*****************************************************************
  150. !subsubnode Option Initialiserung $I
  151. !stg @alabel $I
  152.  
  153. Diese Option erzeugt als Debughilfe besonderen Code bei jedem BEGIN: für 
  154. Prozeduren wird der Platz der lokalen Variablen mit -1 initialisiert, 
  155. für den Modulrumpf werden die globalen Variablen mit -1 belegt. Dadurch 
  156. lassen sich uninitialisierte Variablen, insbesondere POINTER, leicht 
  157. entdecken, da ein Vergleich auf NIL fehlschlägt und ein Zugriff einen 
  158. Adreßfehler (Exception #3) auslöst und danach mit den Debuggern leicht 
  159. lokalisiert werden kann.
  160.  
  161. #*****************************************************************
  162. !subsubnode Option Stacktest $S
  163. !stg @alabel $S
  164.  
  165. Ist die S-Option aktiv, so wird bei Prozedureintritt ein Stacktest 
  166. durchgeführt. Ohne Überprüfung könnte der Stack in einen Daten- oder 
  167. Codebereich einer anderen Routine wachsen. Ein Stack-Überlauf führt zu 
  168. einem Laufzeitfehler.
  169.  
  170. #*****************************************************************
  171. !subsubnode Option Overflow $V
  172. !stg @alabel $V
  173.  
  174. Ist diese Option aktiviert, so wird bei arithmetischen Operationen ein 
  175. Überlaufstest durchgeführt und im Fehlerfall ein Laufzeitfehler
  176. erzeugt.
  177.  
  178. #*****************************************************************
  179. !subsubnode Option Rangetest $T
  180. !stg @alabel $T
  181.  
  182. Ist diese Option aktiviert, so wird bei Zuweisungen, Parameterübergaben 
  183. und Array-Indizierungen ein Bereichstest durchgeführt. Eine 
  184. Bereichsüberschreitung führt zu einem Laufzeitfehler.
  185.  
  186. #*****************************************************************
  187. !subsubnode Option Statische Checks $X
  188. !stg @alabel $X
  189.  
  190. Durch Ausschalten dieser Option können statische Checks während der 
  191. Übersetzung deaktiviert werden. In diesem Fall werden auch die über 
  192. $T+ aktivierten Rangechecks abgeschaltet. Der erzeugte Code wird 
  193. nicht beeinflußt. Bei eingeschalteter Option wird u.a. entdeckt, wenn 
  194. einer SHORTCARD-Variablen eine negative Konstante zugewiesen oder bei 
  195. einem Array auf ein ungültiges Element zugegriffen wird (bei konstantem 
  196. Index). Wird bei einer BITSET-Variablen mittels IN geprüft, ob eine 
  197. Konstante kleiner 0 oder größer 15 enthalten ist, so kommt es ebenfalls 
  198. zu einer Fehlermeldung. Dies gilt analog für alle Mengen-Variablen. 
  199. Letzteres führt übrigens nie zu einem Laufzeitfehler, sondern liefert 
  200. korrekterweise einfach FALSE. Übersetzen kann man diese Anweisung nur 
  201. mit $X-, generiert wird dann direkt FALSE. Außerdem wird über diese 
  202. Option die Überprüfung der Existenz einer RETURN-Anweisung in einer 
  203. Funktionsprozedur abgeschaltet.
  204.  
  205. #*****************************************************************
  206. !subsubnode Option Laufzeitüberprüfungen $Y
  207. !stg @alabel $Y
  208.  
  209. Über diese Option werden verschiedene Laufzeitüberprüfungen aktiviert. 
  210. Zum einen handelt es sich dabei um die Überprüfung des RETURN-Statements 
  211. einer Funktionsprozedur. Wird eine solche fälschlicherweise nicht über 
  212. RETURN verlassen, so führt dies zu einem Laufzeitfehler. Zum anderen 
  213. findet eine Überprüfung der CASE-Anweisung statt. Kommt es in einem 
  214. CASE-Statement ohne ELSE zu einer Variante, die nicht abgefragt wird, so 
  215. wird ein Laufzeitfehler ausgelöst. Schließlich wird überprüft, ob in 
  216. einer FORM-Zuweisung das Ziel unerlaubterweise als Folgeparameter 
  217. auftritt:
  218.  
  219. !begin_verbatim
  220.      str := FORM(str,' Suffix'); (* erlaubt              *) 
  221.      str := FORM('Präfix ',str); (* Laufzeitfehler *) 
  222. !end_verbatim
  223.  
  224. #*****************************************************************
  225. !subsubnode Option Warnungen $Q
  226. !stg @alabel $Q
  227.  
  228. Bei Aktivierung dieser Option werden Warnungen unterdrückt.
  229.  
  230. #*****************************************************************
  231. !subsubnode Option Hänisch-Spezifika $H
  232. !stg @alabel $H
  233.  
  234. Diese Option mindert die Akzeptanz für Hänisch-Modula-spezifische 
  235. Konstrukte: die Verwendung von BREAK, CONTINUE, FORM, STRING, VOID, 
  236. Pointer-INC/DEC usw. liefert dann eine Warnung.
  237.  
  238. #*****************************************************************
  239. !subsubnode Option Nullterminierte Strings $G
  240. !stg @alabel $G
  241.  
  242. Ist diese Option aktiviert, so geht der Compiler von 0C-terminierten 
  243. Strings aus (im Unterschied zu HIGH-Wert-terminierten). Bei 
  244. eingeschalteter Option $G+ wird dann z.B.
  245.  
  246. !begin_verbatim
  247.  
  248.     VAR str: ARRAY[0..4] OF CHAR;
  249.     ...
  250.     s := 'Hallo';
  251. !end_verbatim
  252.  
  253. als Fehler gemeldet, da in str kein abschließendes 0C hineinpaßt.
  254.  
  255. #*****************************************************************
  256. !subsubnode Option WORD-Breite $W
  257. !stg @alabel $W
  258.  
  259. Diese Option bezieht sich auf die Speicherbelegung von Aufzählungs-,
  260. Unterbereichs- und Mengentypen. Für diese Typen wird normalerweise
  261. ein kleinstmöglicher Speicher in Byte-Schritten reserviert. Mit der
  262. W-Option kann der kleinste Speicherbereich auf zwei Bytes gesetzt
  263. werden.
  264.  
  265. #*****************************************************************
  266. !subsubnode Option LONG-Breite $L
  267. !stg @alabel $L
  268.  
  269. Diese Option betrifft die Speicherbelegung von Aufzählungs-,
  270. Unterbereichs- und Mengentypen. Für diese Typen wird normalerweise
  271. ein kleinstmöglicher Speicher in Byte-Schritten reserviert. Mit der
  272. L-Option kann der kleinste Speicherbereich auf vier Bytes gesetzt
  273. werden.
  274.  
  275. #*****************************************************************
  276. !subsubnode Option Prozedur-Prolog und -Epilog $P
  277. !stg @alabel Epilog
  278. !stg @alabel Prolog
  279. !stg @alabel $P
  280.  
  281. Wird diese Option eingeschaltet, so wird für Prozeduren kein Prolog und 
  282. Epilog erzeugt. Prolog und Epilog dienen v. a. zum Retten und 
  283. Restaurieren von Registern und zum Anlegen eines lokalen 
  284. Variablenbereichs. Auch Stackcheck ($S+) und Initialisierung der 
  285. Variablen ($I+) erfolgen im Prolog.
  286.  
  287. #*****************************************************************
  288. !subsubnode Option Eintrittscode $E
  289. !stg @alabel $E
  290.  
  291. Für exportierte Prozeduren wird ein besonderer Eintritts-Code erzeugt. 
  292. Prozedur-Variablen und Prozedur-Parameter dürfen nur Prozeduren 
  293. zugewiesen werden, die diesen Eintritts-Code enthalten. Die Erzeugung 
  294. des Eintritts-Codes kann mit dieser Option eingeschaltet werden. Ist 
  295. gleichzeitig P eingeschaltet, so wird kein Eintritts-Code erzeugt, die 
  296. Prozedur kann aber für Variablen und Parameter benutzt werden.
  297.  
  298. #*****************************************************************
  299. !subsubnode Option Main-Modul $M
  300. !stg @alabel $M
  301.  
  302. Diese Option verhindert, daß ein Modul beim optimierenden Linken 
  303. gegebenenfalls vollständig entfernt wird. Dies ist nötig, wenn das Modul im 
  304. Modulrumpf Initialisierungen vornimmt, die auch dann benötigt werden, wenn 
  305. keine Variable oder Prozedur des Moduls von anderen Modulen benutzt wird.
  306.  
  307. #*****************************************************************
  308. !subsubnode Option Registervariable $R oder $Reg
  309. !stg @alabel $R
  310. !stg @alabel $Reg
  311.  
  312. Die nächste Variable wird in einem Register gehalten. Voraussetzung ist, 
  313. daß sie nicht breiter als 32-Bit ist und lokal in einer Prozedur 
  314. deklariert wurde. Bei aktivierter Option <f> können Fließkommavariablen 
  315. in FPU-Registern gehalten werden. Diese Option wird automatisch 
  316. zurückgesetzt. Wenn eine Deklaration der Form
  317.  
  318. !begin_verbatim
  319.             (*$Reg*) n, m: INTEGER;
  320. !end_verbatim
  321.  
  322. verwendet wird, bezieht sich die Option $Reg nur auf die Variable <n>. 
  323. Die nächste Variable (im Beispiel <m>) würde wieder normal im Speicher 
  324. gehalten werden. POINTER-Variablen werden in Adreßregister gelegt, 
  325. REAL-Variablen bei aktivierter Option <f> in FPU-Register.
  326.  
  327. N.B.: Bei den Direktiven $R, $Reg, $RD, $R4 und $RTE wird kein 
  328. anschließendes "+", "-" oder "=" erwartet. 
  329.  
  330. #*****************************************************************
  331. !subsubnode Option Datenregister $RD oder $RData
  332. !stg @alabel $RD
  333. !stg @alabel $RData
  334.  
  335. Mittels $RD kann man ein Datenregister verlangen, z.B. wenn kein 
  336. Adreßregister mehr zur Verfügung steht oder eine SHORTREAL-Variable bei 
  337. aktivierter Option <f> in ein Datenregister gelegt werden soll:
  338.  
  339. !begin_verbatim
  340.             (*$RD*) ptr: POINTER TO CHAR;
  341.             (*$RD*) val: SHORTREAL;
  342. !end_verbatim
  343.  
  344. N.B.: Bei den Direktiven $R, $Reg, $RD, $R4 und $RTE wird kein 
  345. anschließendes "+", "-" oder "=" erwartet. 
  346.  
  347. #*****************************************************************
  348. !subsubnode Option Adreßregister A4 $R4
  349. !stg @alabel $R4
  350.  
  351. Mittels $R4 kann man bei aktivierter Option statt einem Adreßregister 
  352. ein Datenregister wählen. (Bei aktivierter Option <4> steht A4 nicht zur 
  353. Verfügung.)
  354.  
  355. N.B.: Bei den Direktiven $R, $Reg, $RD, $R4 und $RTE wird kein 
  356. anschließendes "+", "-" oder "=" erwartet. 
  357.  
  358. #*****************************************************************
  359. !subsubnode Option Return From Exception $RT oder $RTE
  360. !stg @alabel $RT
  361. !stg @alabel $RTE
  362.  
  363. Diese Variante bezieht sich nicht auf Variablen, sondern auf Prozeduren: 
  364. sie schlieβt die nächste bzw. aktuelle Prozedur (und nur diese) mit RTE 
  365. statt RTS ab (Test am Ende der Prozedur), aber nur dann, wenn diese 
  366. Prozedur tatsächlich mit RTS abschlieβe, also parameterlos, $K+ oder 
  367. ähnliches ist. 
  368.  
  369. N.B.: Bei den Direktiven $R, $Reg, $RD, $R4, $RO und $RTE wird kein 
  370. anschließendes "+", "-" oder "=" erwartet. 
  371.  
  372. #*****************************************************************
  373. !subsubnode Option ReadOnly-Variablen $RO
  374. !stg @alabel $RO
  375. !stg @alabel "ReadOnly-Variablen"
  376.  
  377. Die Direktive $RO erlaubt die Deklaration von ReadOnly-Variablen und 
  378. Parametern. $RO muβ wie $Reg vor den Namen der Variable gesetzt werden 
  379. und gilt nur für eine Variable. Sinnvoll ist die Direktive vor allem für 
  380. Referenzparameter und Variablen in Definitions (diese können im 
  381. zugehörigen Implementation verändert werden, andere Module können sie 
  382. nur lesen). Auch in der formalen Parameterliste eines Prozedurtyps wird 
  383. die Direktive unterstützt; sie muβ dort vor dem jeweiligen Typnamen 
  384. stehen.
  385.  
  386. N.B.: Bei den Direktiven $R, $Reg, $RD, $R4, $RO und $RTE wird kein 
  387. anschließendes "+", "-" oder "=" erwartet. 
  388.  
  389. #*****************************************************************
  390. !subsubnode Option Real-Rückgabe $R0
  391. !stg @alabel $R0
  392.  
  393. Bei aktivierter Option <f> (Coprozessor) werden REAL-Funktionsergebnisse 
  394. normalerweise in FP0 zurückgegeben. Mittels der Option $R0 kann dies 
  395. unterbunden werden (Default: $R0+); dann erfolgt die Rückgabe in D0 bzw. 
  396. D0/D1. Die Art der Rückgabe gehört zum Prozedurtyp. 
  397.  
  398. #*****************************************************************
  399. !subsubnode Option Scratchregister $R1
  400. !stg @alabel $R1
  401.  
  402. Die Option $R1+ veranlaßt, daß auch Scratchregister im 
  403. Prozedurprolog/-epilog gesichert und restauriert werden.
  404.  
  405. #*****************************************************************
  406. !subsubnode Option Registerrettung $R2
  407. !stg @alabel $R2
  408.  
  409. Die Option $R2+ veranlaßt im Prozedurtyp, daß vor Aufruf einer 
  410. entsprechenden Prozedur ggf. die Register D2/A2/FP1/FP2 gerettet und 
  411. nach Rückkehr restauriert werden. Dieser Status gehört zum Prozedurtyp. 
  412. Sinn dieser Option ist der Aufruf externer Routinen (z.B. per 
  413. Cookie-Tabelle), die diese Register als Scratchregister ansehen.
  414.  
  415. #*****************************************************************
  416. !subsubnode Option Stack-Korrektur $K
  417. !stg @alabel $K
  418. !stg @alabel Stack-Korrektur
  419.  
  420. Diese Option steuert, ob der Rufer einer Prozedur oder die Prozedur 
  421. selbst die übergebenen Parameter wieder vom Stack entfernt. Bei 
  422. eingeschalteter Option nimmt der Rufer die Korrektur vor. Nach jedem 
  423. Prozeduraufruf wird also entsprechender Code erzeugt. Bei 
  424. ausgeschalteter Option übernimmt die gerufene Prozedur diese Korrektur 
  425. selbst, was i.a. eine Codeverkürzung bewirkt, da die Prozedur selbst 
  426. dadurch zwar einige wenige Bytes länger wird, bei jedem Aufruf aber 2 
  427. bis 4 Bytes gespart werden. Bei eingeschalteter Option <2> kann eine 
  428. Prozedur unter Verwendung der RTD-Instruktion verlassen werden, sodaß 
  429. der Code nie länger wird.
  430.  
  431. Die Stellung des K-Schalters ist Teil des Prozedurtyps. Dieser wird beim 
  432. Übersetzen einer Prozedurtyp-Deklaration oder der Prozedurköpfe eines 
  433. DEFINITION MODULEs festgelegt.
  434.  
  435. Im IMPLEMENTATION MODULE muß die Stellung der Option für jede Prozedur 
  436. übereinstimmen und nur Prozedurtypen mit gleicher Stack-Korrektur sind 
  437. kompatibel. Gegebenenfalls wird ein Fehler gemeldet. Allerdings ist die 
  438. Aktivierung dieser Option nur sehr selten nötig.
  439.  
  440. Notwendig ist sie z.B. bei objc.tUserProc, da das AES davon ausgeht, daß 
  441. es den Stack selbst korrigieren muß.
  442.  
  443. #*****************************************************************
  444. !subsubnode Option BYTE-Werteparameter $B
  445. !stg @alabel $B
  446.  
  447. Diese Option steuert die Übergabe von Byte-Werteparametern, also z.B. 
  448. Parameter des Typs CHAR oder BOOLEAN. Bei eingeschalteter Option wird 
  449. der Parameter zu einem Wort ausgedehnt und als solches übergeben (der 
  450. Parameter liegt dann an ungerader Adresse, das Füllbyte an gerader), 
  451. ansonsten als Byte (der Parameter liegt dann an gerader Adresse und das 
  452. Füllbyte an ungerader). Die Übergabe mit $B+ ist zeit- und 
  453. codeaufwendiger, kann jedoch bei direkter Parameterübergabe an das 
  454. Betriebssystem nötig sein.
  455.  
  456. #*****************************************************************
  457. !subsubnode Option Debugging-Informationen $D
  458. !stg @alabel $D
  459.  
  460. Diese Option ist per Default aktiv. Ist sie abgeschaltet, so erzeugt der 
  461. Compiler keine Zeileninformation für die Debugger. Dies ist wichtig für 
  462. Prozeduren, die als Datenbereich benutzt werden sollen.
  463.  
  464. Falls zusätzlich auch Option <d> aktiv ist, so wird der Debug-Code 
  465. älterer Compiler-Versionen erzeugt:
  466.  
  467. In den erzeugten Code des Programmes werden Debug-Informationen 
  468. eingesetzt. Nach jeder Modula-Anweisung wird die Zeilennummer im 
  469. Quelltext durch folgende Instruktionen abgelegt:
  470.  
  471. !begin_verbatim
  472.             BRA.S      *+4                 ;$6002
  473.             DC.W         $A000 + Zeilennummer
  474. !end_verbatim
  475.  
  476. Am Ende einer Prozedur oder eines Moduls wird deren Name abgelegt. Dazu 
  477. wird folgender Code erzeugt.
  478.  
  479. !begin_verbatim
  480.             RTS
  481.             BRA.S      *+4                 ;$6002
  482.             DC.W         $A000
  483.             DC.B         'Name', 0     ;Name der Prozedur bzw. des Moduls
  484. !end_verbatim
  485.  
  486. Die Zeilennummer wird also jeweils übersprungen, sodaß auch ein mit 
  487. diesem Debug-Code versehenes Programm normal lauffähig ist.
  488.  
  489.  
  490. #*****************************************************************
  491. # Linker
  492. #*****************************************************************
  493. !subnode Linker-Optionen
  494.  
  495. !subsubtoc [html, stg]
  496. #*****************************************************************
  497. !subsubnode Linkeroption <2> (mc68020)
  498.  
  499. Diese Option steuert, ob im erzeugten Programm Code für die Prozessoren 
  500. MC68020/30 enthalten sein darf oder nicht. Dies ist der Fall, wenn die 
  501. Option aktiv ist.
  502.  
  503. #*****************************************************************
  504. !subsubnode Linkeroption <f> (Coprozessor)
  505.  
  506. Diese Option steuert, ob im erzeugten Programm Code für den mathematischen 
  507. Coprozessor MC68881/882 enthalten sein darf oder nicht. Dies ist der Fall, 
  508. wenn die Option aktiv ist.
  509.  
  510. #*****************************************************************
  511. !subsubnode Linkeroption <4> (Reg. A4 sperren)
  512.  
  513. Diese Option steuert, ob im erzeugten Programm das CPU-Register A4 
  514. verwendet werden darf oder nicht. Ist die Option aktiviert, so darf A4 
  515. nicht verwendet werden. Dies ist nur für RTOS nötig, ansonsten unsinnig. 
  516.  
  517. #*****************************************************************
  518. !subsubnode Linkeroption <l> (LST-Datei)
  519.  
  520. Will man eine Übersicht über die beim optimierenden Linken entfernten 
  521. Prozeduren erhalten, so kann man über diese Option eine ASCII-Datei mit 
  522. der Extension .LST, die die Optimierungen protokolliert, mit folgendem 
  523. Format erzeugen:
  524.  
  525. !begin_verbatim
  526.     LST          ::= {Module}.
  527.     Module     ::= ModuleName EOL {DelProc} [HeadSave].
  528.     DelProc  ::= Number "  " ProcName EOL.
  529.     HeadSave ::= Number "  (HT)" EOL.
  530.     Number - fünfstellige Dezimalzahl mit führenden Blanks.
  531. !end_verbatim
  532.  
  533. #*****************************************************************
  534. !subsubnode Linkeroption <s> (SYM-Datei)
  535. !stg @alabel SYM-Datei
  536.  
  537. Ist diese Option aktiviert, so wird beim Linken eine SYM-Datei erzeugt. 
  538. Diese Datei wird von den Debuggern benötigt (vgl. <v>).
  539.  
  540. #*****************************************************************
  541. !subsubnode Linkeroption <v> (Archive in SYM-Datei)
  542.  
  543. Die SYM-Datei enthält normalerweise nur Informationen zu Modulen, deren 
  544. Object (B-Datei) sich nicht in einem Archiv befindet. Ist zusätlich zu 
  545. <s> auch <v> aktiviert, so werden für alle Module Informationen in die 
  546. SYM-Datei geschrieben.
  547.  
  548. #*****************************************************************
  549. !subnode Datentypen und deren Speicherbelegung
  550. !stg @alabel Datentypen
  551. !stg @alabel Speicherbelegung
  552.  
  553. Hänisch-Modula-2 kennt zwei Grundtypen für ganzzahlige Werte: 
  554. vorzeichenbehaftete und vorzeichenlose Typen. Innerhalb beider 
  555. Grundtypen gibt es Typen verschiedener Gröβe (ein, zwei oder vier Byte). 
  556. Alle diese Typen sind zuweisungskompatibel. Darüberhinaus sind innerhalb 
  557. eines Grundtyps alle Typen operatorkompatibel. Somit kann man z.B. (ohne 
  558. explizite Angabe einer Typkonvertierung) eine Variable vom Typ SHORTINT 
  559. an eine Variable vom Typ LONGCARD zuweisen (und umgekehrt) und auch die 
  560. Addition einer Variable vom Typ SHORTINT zu einer Variablen vom Typ 
  561. LONGINT ist möglich. Der Compiler erzeugt automatisch Code, falls eine 
  562. Typkonvertierung nötig ist. Optional kann auch Code für die 
  563. Bereichsüberschreitung bei solchen Operationen erzeugt werden.
  564.  
  565. Unterbereichstypen können explizit vorzeichenbehaftet oder vorzeichenlos 
  566. deklariert werden. Im folgenden Beispiel ist t1 vorzeichenbehaftet und t2 
  567. vorzeichenlos:
  568.  
  569. !begin_verbatim
  570. TYPE
  571.     t1 = SHORTINT [1..20];
  572.     t2 =                    [1..20];
  573. !end_verbatim
  574.  
  575. Analog sind die Typen SHORTREAL und LONGREAL zueinander operatorkompatibel.
  576.  
  577. !label CARDINAL
  578. !label SHORTCARD
  579. !label LONGCARD
  580. !label INTEGER
  581. !label SHORTINT
  582. !label LONGINT
  583. !label CHAR
  584. !label BOOLEAN
  585. !label POINTER
  586. !label Unterbereich
  587. !begin_verbatim
  588. ======================================================================
  589. Typ                 Größe      Wertebereich
  590. ----------------------------------------------------------------------
  591. CARDINAL        2/4          vgl. SHORTCARD / LONGCARD und Option <w>
  592. SHORTCARD     2              0 bis 65535
  593. LONGCARD        4              0 bis 4294967295
  594.  
  595. INTEGER         2/4          vgl. SHORTINT / LONGINT und Option <i>
  596. SHORTINT        2              -32768 bis 32767
  597. LONGINT         4              -2147483648 bis 2147483647
  598.  
  599. CHAR                1              0C bis 377C    (0 bis 255)
  600. BOOLEAN         1              FALSE bis TRUE
  601.  
  602. POINTER         4              0 bis 4294967295
  603.  
  604. Unterbereich 1/2/4     je nach Größe (max. -2147483648 bis 2147483647)
  605. ======================================================================
  606. !end_verbatim
  607.  
  608. !label TRUE
  609. !label FALSE
  610. Der Typ BOOLEAN ist definiert als BOOLEAN = (FALSE, TRUE). Es handelt 
  611. sich also um einen Aufzählungstyp, wobei TRUE für eine erfüllte 
  612. Bedingung steht.
  613.  
  614. !label NIL
  615. Für Pointer existiert die Konstante NIL. Diese Konstante besitzt den 
  616. Wert 0 und dient als Kennzeichnung eines Pointers, der nirgends 
  617. hinzeigt. NIL ist zuweisungskompatibel zu allen Pointertypen.
  618.  
  619. !label REAL
  620. !label SHORTREAL
  621. !label LONGREAL
  622. !begin_verbatim
  623. ======================================================================
  624. Typ                 Größe      Wertebereich                                              min. Betrag
  625. ----------------------------------------------------------------------
  626. REAL                4/8          vgl. SHORTREAL / LONGREAL und Option <r>
  627. SHORTREAL     4              -3.402823E+38 bis 3.402823E+38          1.17549E-38
  628. LONGREAL        8              -1.797693E+308 bis 1.797693E+308      2.225074E-308
  629. ======================================================================
  630. !end_verbatim
  631.  
  632. Hänisch Modula-2 rechnet bei REAL-Typen (außer bei aktivierter Option 
  633. <f>, also direkter Verwendung des mathematischen Coprozessors) immer mit 
  634. LONGREALs. Das Rechnen mit SHORTREALs ist daher langsamer, da diese erst 
  635. in LONGREALs umgewandelt werden!
  636.  
  637. !label BYTESET
  638. !label BITSET
  639. !label LONGSET
  640. !label CHARSET
  641. !label SET OF
  642. !label Aufzählung
  643. !begin_verbatim
  644. ======================================================================
  645. Typ                 Größe      (maximale) Anzahl der Elemente
  646. ----------------------------------------------------------------------
  647. BYTESET         1              8
  648. BITSET            2              16
  649. LONGSET         4              32
  650. CHARSET         32             256
  651. SET OF Type 1-4096     8-32768
  652. Aufzählung    1/2          256/65535
  653. ======================================================================
  654. !end_verbatim
  655.  
  656. Die Mengentypen sind wie folgt definiert:
  657.  
  658. !begin_verbatim
  659.     BYTESET = SET OF [0..7];
  660.     BITSET    = SET OF [0..15];
  661.     LONGSET = SET OF [0..31];
  662.     CHARSET = SET OF CHAR;
  663. !end_verbatim
  664.  
  665. Bei den Typen BYTESET, LONGSET und CHARSET handelt es sich um 
  666. HM2-Erweiterungen.
  667.  
  668. #*****************************************************************
  669. !subsubnode STRING
  670.  
  671. Zusätzlich zu den bereits erläuterten Datentypen verfügt HM über den 
  672. Datentyp STRING. Strings sind zu den formalen Parametern ARRAY OF CHAR 
  673. kompatibel, haben aber keinen HIGH-Wert. Sie werden immer durch ein 
  674. Null-Byte (0C) abgeschlossen. Dieser Typ darf nur in der formalen 
  675. Parameterliste einer Prozedur benutzt werden. Der Datentyp STRING 
  676. erlaubt es, einem VAR-Parameter eine Konstate zu übergeben!
  677.  
  678. !begin_verbatim
  679.     PROCEDURE WriteStr (VAR Str: STRING);
  680.     BEGIN
  681.     END WriteStr;
  682.  
  683.     BEGIN
  684.         WriteString ("Hello World!");
  685. !end_verbatim
  686.  
  687. #*****************************************************************
  688. !subnode Aggregate
  689.  
  690. Aggregate sind eine Zusammenfassung mehrerer Ausdrücke bzw. Werte zu 
  691. einem Record oder zu einem Array. Aggregate erlauben es, eine Record- 
  692. bzw. Array-Variable durch eine einzige Zuweisung komplett zu 
  693. initialisieren und ermöglichen die Deklaration strukturierter 
  694. Konstanten. Ein Aggregat wird eingeleitet durch einen Typnamen (Array- 
  695. oder Record-Typ). Diesem folgt, eingeschlossen in geschweifte Klammern, 
  696. die Aufzählung der Elemente. Tritt ein Aggregat als Element eines 
  697. anderen Aggregats auf, so kann die Angabe des Typnamens fehlen. Bei 
  698. Aggregaten eines Array-Typs kann bei den Elementen ein konstanter 
  699. Wiederholungsfaktor angegeben werden. Dieser wird mit "BY" an einen 
  700. Ausdruck angehängt. Der Ausdruck wird dabei nur einmal ausgewertet 
  701. (wichtig, falls der Ausdruck einen Prozeduraufruf enthält). 
  702.  
  703. Beispiel:
  704.  
  705. !begin_verbatim
  706. TYPE
  707.      tR = RECORD i: SHORTINT; ch: CHAR; b: BOOLEAN END;
  708.      tA = ARRAY [0..2] OF tR;
  709.      tA2 = ARRAY [0..9] OF SHORTINT;
  710. CONST
  711.      cR = tR{-1, 'A', TRUE};
  712.      cA = tA2{-1 BY 3, 0, 1, 2, 3 BY 4};
  713. VAR
  714.      A: tA;
  715.      i: SHORTINT;
  716.      ch: CHAR;
  717. BEGIN
  718.      A := tA{cR, {i, 'B', i=0}, tR{i*i, ch, FALSE}};
  719. !end_verbatim
  720.  
  721.  
  722. #*****************************************************************
  723. !subnode Standardprozeduren
  724.  
  725. Die nachfolgend aufgeführten Prozeduren sind immer vorhanden. Der Compiler 
  726. erzeugt bei ihrer Verwendung zum Teil direkt Code, d. h. es handelt sich 
  727. nicht um echte Prozeduren. Die Ergebnisse der Funktionsprozeduren können bei 
  728. konstanten Argumenten auch als Konstante verwendet werden.
  729.  
  730. #*****************************************************************
  731. !subsubnode ABS
  732.  
  733. PROCEDURE ABS (x: Type): Type;
  734.  
  735. Diese Funktionsprozedur liefert den Absolutbetrag des übergebenen 
  736. Wertes. Die Argumente können ganze Zahlen oder Fließkommazahlen sein. 
  737. Der Ergebnistyp ist gleich dem Argumenttyp.
  738.  
  739. #*****************************************************************
  740. !subsubnode CAP
  741.  
  742. PROCEDURE CAP (ch: CHAR): CHAR;
  743.  
  744. Diese Funktionsprozedur liefert für Kleinbuchstaben den zugehörigen 
  745. Großbuchstaben, für sonstige Zeichen das übergebene Zeichen. Es werden 
  746. nur die Zeichen 'a' bis 'z' berücksichtigt, keine nationalen 
  747. Sonderzeichen.
  748.  
  749. #*****************************************************************
  750. !subsubnode CHR
  751.  
  752. PROCEDURE CHR (ord: CARDINAL): CHAR;
  753.  
  754. Diese Funktionsprozedur liefert das zur übergebenen Ordnungszahl 
  755. gehörende Zeichen. CHR (ord) ist identisch zu VAL (CHAR, ord).
  756.  
  757. #*****************************************************************
  758. !subsubnode DEC
  759.  
  760. PROCEDURE DEC (x)
  761.  
  762. PROCEDURE DEC (x, n)
  763.  
  764. (vgl. INC)
  765. Diese Prozedur verringert den Wert der übergebenen Variable um eins. 
  766. Optional kann ein zweiter Parameter angegeben werden. Dann wird die 
  767. Variable um den Wert des zweiten Parameters verringert.
  768.  
  769. Diese Prozedur kann auf Argumente verschiedenen Typs angewendet werden:
  770. !begin_itemize
  771. !item ganze Zahlen
  772. !item Aufzählungstypen (auch BOOLEAN)
  773. !item CHAR
  774. !item Fließkommazahlen
  775. !item Pointer
  776. !end_itemize
  777.  
  778. Bei Aufzählungstypen erhält die Variable als Wert den (n-ten) Vorgänger. 
  779. Fließkommazahlen und Pointer als Argumente sind eine Erweiterung unter 
  780. Hänisch Modula-2. Bei Fließkommazahlen muß ein zweiter Parameter 
  781. vorhanden sein. Bei Pointern wird der Wert des Pointers nicht um 1 bzw. 
  782. n verringert, sondern um die (n-fache) Größe des Typs, auf den der 
  783. Pointer zeigt.
  784.  
  785. #*****************************************************************
  786. !subsubnode DISPOSE
  787.  
  788. PROCEDURE DISPOSE (VAR Pointer)
  789.  
  790. Diese Prozedur gibt einen mit NEW allozierten Speicherberich wieder 
  791. frei. Dazu muß eine Prozedur DEALLOCATE deklariert sein. Diese kann man 
  792. von Storage importieren; man kann aber auch eine andere zur Verfügung 
  793. stellen. DISPOSE (p) ist identisch mit DEALLOCATE (p, SYSTEM.TSIZE (t)), 
  794. falls p als POINTER TO t deklariert ist (vgl. NEW).
  795.  
  796. #*****************************************************************
  797. !subsubnode EXCL
  798.  
  799. PROCEDURE EXCL (Menge, Element)
  800.  
  801. Diese Prozedur entfernt ein Element aus einer Menge (vgl. INCL).
  802.  
  803. #*****************************************************************
  804. !subsubnode FORM
  805.  
  806. PROCEDURE FORM (x1, ... , xn): STRING;
  807.  
  808. FORM dient zur String-Formatierung. Die Anzahl der Parameter ist 
  809. beliebig. Als Parameter können der Prozedur Zeichen, Zahlen und Strings 
  810. übergeben werden. Diese werden zu einem String zusammengefügt. Bei den 
  811. Parametern sind auch Formatangaben möglich. Diese folgen dem Parameter 
  812. durch ':' getrennt. Die Angaben haben folgende Bedeutung: 
  813.  
  814. !begin_verbatim
  815.     bei ganzen Zahlen: Mindestbreite : Basis : Füllzeichen 
  816.     bei REALs:                 Mindestbreite : Nachkommastellen : Füllzeichen bei 
  817.     Strings:                     Mindestbreite : Füllzeichen
  818. !end_verbatim
  819.  
  820. Für die einzelnen Angaben sind konstante Ausdrücke zulässig. 
  821. 'Mindestbreite' und 'Nachkommastellen' dürfen im Bereich von -128 bis 
  822. 127 liegen, Basis im Bereich von 2 bis 32. Negative Werte für die 
  823. Mindestbreite führen zu linksbündiger Ausgabe, positive zu 
  824. rechtsbündiger. Die einzelnen Formatangaben sind optional. Defaults:
  825.  
  826. !begin_verbatim
  827.         Mindestbreite         1
  828.         Basis                         10
  829.         Nachkommastellen    0
  830.         Füllzeichen             ' '
  831. !end_verbatim
  832.  
  833.  
  834. Beispiel:
  835. !begin_verbatim
  836.     VAR
  837.          i: SHORTINT;
  838.          r: REAL;
  839.          s: ARRAY[0..10] OF CHAR;
  840.          c: CHAR;
  841.          Str: ARRAY [0..99] OF CHAR;
  842.     BEGIN
  843.          Str := FORM ("Wert: ", i:4:16:'0', " String: ", s:-8, " Zeichen: ",
  844.                                      c, " Real: ", r::5);
  845.          WriteString (Str);
  846. !end_verbatim
  847.     
  848. 'i' wird als 4-stellige Hexadezimalzahl mit führenden Nullen ausgegeben,
  849. 's' wird bis zu einer Gesamtlänge von 8 Zeichen hinten mit Leerzeichen 
  850. aufgefüllt und 'r' wird mit 5 Nachkommastellen ausgegeben.
  851.  
  852. FORM ist eine Erweiterung von Hänisch Modula-2.
  853.  
  854. #*****************************************************************
  855. !subsubnode FLOAT
  856.  
  857. PROCEDURE FLOAT (Integer): LONGREAL;
  858.  
  859. Diese Funktionsprozedur wandelt eine ganze Zahl (d.h. INTEGER oder 
  860. CARDINAL) in eine Fließkommazahl (vgl. INT, TRUNC).
  861.  
  862. #*****************************************************************
  863. !subsubnode HALT
  864. PROCEDURE HALT
  865.  
  866. Bei Aufruf dieser Prozedur wird das Programm abgebrochen.
  867.  
  868. #*****************************************************************
  869. !subsubnode HIGH
  870. PROCEDURE HIGH (Array): LONGCARD;
  871.  
  872. Diese Funktionsprozedur liefert für offene Arrays (also 
  873. Prozedurparameter mit ARRAY OF Type als Typ) den größten zulässigen 
  874. Index für Zugriffe auf das übergebene Array. Wird z.B. die Prozedur
  875.  
  876.     PROCEDURE p (open: ARRAY OF CHAR);
  877.  
  878. mit einem Array a: ARRAY [5..80] OF CHAR aufgerufen, so sind in der 
  879. Prozedur Zugriffe auf die Elemente open[0] bis open[HIGH(open)] zulässig 
  880. (HIGH(open) = 75).
  881.  
  882. #*****************************************************************
  883. !subsubnode INC
  884. PROCEDURE INC (x)
  885.  
  886. PROCEDURE INC (x, n)
  887.  
  888. (vgl. DEC)
  889. Diese Prozedur erhöht den Wert der übergebenen Variable um eins. 
  890. Optional kann ein zweiter Parameter angegeben werden. Dann wird die 
  891. Variable um den Wert des zweiten Parameters erhöht.
  892.  
  893. Diese Prozedur kann auf Argumente verschiedenen Typs angewendet werden:
  894. !begin_itemize
  895. !item ganze Zahlen
  896. !item Auzählungstypen (auch BOOLEAN)
  897. !item CHAR
  898. !item Fließkommazahlen
  899. !item Pointer
  900. !end_itemize
  901.  
  902. Bei Aufzählungstypen erhält die Variable als Wert den (n-ten) 
  903. Nachfolger. Fließkommazahlen und Pointer als Argumente sind eine 
  904. Erweiterung unter Hänisch Modula-2. Bei Fließkommazahlen muß ein zweiter 
  905. Parameter vorhanden sein. Bei Pointern wird der Wert des Pointers nicht 
  906. um 1 bzw. n erhöht, sondern um die (n-fache) Größe des Typs, auf den der 
  907. Pointer zeigt.
  908.  
  909. #*****************************************************************
  910. !subsubnode INCL
  911. PROCEDURE INCL (Menge, Element)
  912.  
  913. Diese Prozedur nimmt ein Element in eine Menge auf (vgl. EXCL).
  914.  
  915. #*****************************************************************
  916. !subsubnode INT
  917. PROCEDURE INT (x): LONGINT;
  918.  
  919. Diese Funktionsprozedur ist für ganzzahlige Typen identisch mit
  920. VAL (LONGINT, x). Für REAL-Typen liefert sie den ganzzahligen Anteil einer 
  921. Fließkommazahl.
  922.  
  923. #*****************************************************************
  924. !subsubnode LENGTH
  925. PROCEDURE LENGTH (String: ARRAY OF CHAR): LONGINT;
  926.  
  927. Diese Funktionsprozedur liefert die Länge des übergebenen Strings unter
  928. Berücksichtigung des HIGH-Wertes. Sie ist insbesondere interessant für die 
  929. Verwendung in konstanten Ausdrücken zur Längenbestimmung symbolischer 
  930. Stringkonstanten.
  931.  
  932. #*****************************************************************
  933. !subsubnode LFLOAT
  934. PROCEDURE LFLOAT (Integer): LONGREAL;
  935.  
  936. Diese Funktionsprozedur ist identisch mit FLOAT.
  937.  
  938. #*****************************************************************
  939. !subsubnode MAX 
  940. PROCEDURE MAX (Type): Type;
  941.  
  942. Diese Funktionsprozedur liefert den Maximalwert des übergebenen Typs. Der 
  943. Ergebnistyp ist abhängig vom übergebenem Typ.
  944.  
  945. #*****************************************************************
  946. !subsubnode MIN
  947. PROCEDURE MIN (Type): Type;
  948.  
  949. Diese Funktionsprozedur liefert den Minimalwert des übergebenen Typs. Der 
  950. Ergebnistyp ist abhängig vom übergebenem Typ. Bei REAL-Typen wird der 
  951. kleinste darstellbare positive Wert geliefert.
  952.  
  953. #*****************************************************************
  954. !subsubnode NEW
  955. PROCEDURE NEW (VAR Pointer);
  956.  
  957. Diese Prozedur alloziert einen Speicherbereich mit der Größe des Typs, auf 
  958. den der Pointer zeigt. Dazu muß eine Prozedur ALLOCATE deklariert sein. 
  959. Diese kann man von Storage importieren; man kann aber auch eine andere zur 
  960. Verfügung stellen. NEW (p) ist identisch mit ALLOCATE (p,SYSTEM.TSIZE (t)), 
  961. falls p als POINTER TO t deklariert ist (vgl. DISPOSE).
  962.  
  963. #*****************************************************************
  964. !subsubnode ODD
  965. PROCEDURE ODD (Integer): BOOLEAN;
  966.  
  967. Diese Funktionsprozedur kann auf ganzzahlige Typen angwendet werden. 
  968. Sie liefert TRUE, falls der übergebene Wert ungerade ist, FALSE falls er 
  969. gerade ist.
  970.  
  971. #*****************************************************************
  972. !subsubnode ORD
  973. PROCEDURE ORD (x): LONGCARD;
  974.  
  975. ORD (x) ist identisch zu VAL (LONGCARD, x)
  976.  
  977. #*****************************************************************
  978. !subsubnode SIZE
  979. PROCEDURE SIZE (x): LONGCARD;
  980.  
  981. Diese Funktionsprozedur liefert die Anzahl von Bytes, die für die 
  982. übergebene Variable an Speicher benötigt werden. (vgl. SYSTEM.TSIZE) 
  983.  
  984. #*****************************************************************
  985. !subsubnode TRUNC
  986. PROCEDURE TRUNC (real: LONGREAL): LONGCARD;
  987.  
  988. Diese Funktionsprozedur liefert den ganzzahligen Anteil einer 
  989. Fließkommazahl. Sie ist nur für positive Werte definiert (vgl. INT).
  990.  
  991. #*****************************************************************
  992. !subsubnode VAL
  993. PROCEDURE VAL (Type, x): Type;
  994.  
  995. Diese Funktionsprozedur liefert einen Wert vom Typ Type, der dem Wert von x 
  996. entspricht. Für einen Aufzählungstyp Farben = (rot, gruen, blau) gilt z.B. 
  997. VAL (Farben, 1) = gruen. Im Gegensatz zur [Typerzwingung] wird hier 
  998. gegebenenfalls Code erzeugt, um den Wert umzuwandeln und die Argumente 
  999. müssen nicht die gleiche Typgröße besitzen.
  1000.  
  1001. #*****************************************************************
  1002. !subsubnode VOID
  1003. PROCEDURE VOID (x);
  1004.  
  1005. Die Prozedur VOID akzeptiert einen Parameter beliebigen Typs, mit dem NICHTS
  1006. gemacht wird. Sinn der Sache ist es, die Zuweisung nicht benötigter 
  1007. Funktionsrückgaben an Dummy-Variablen zu vermeiden.
  1008. Beispiel:
  1009. !begin_verbatim
  1010.                 VOID (form.alert (1, '[1][Eine Meldung!][AHA]');
  1011. !end_verbatim
  1012.  
  1013. VOID ist eine Erweiterung von Hänisch Modula-2.
  1014.  
  1015. #*****************************************************************
  1016. !subnode Das SYSTEM-Modul
  1017. !label SYSTEM
  1018.  
  1019. Das Pseudo-Modul SYSTEM wird nicht aus einer Objekt-Datei gelesen, sondern
  1020. ist bereits im Compiler integriert. Einige der Funktionen sind generisch
  1021. und haben keine vordefinierten Parameter. Im HM-Compiler sind folgende
  1022. Konstanten, Typen und Funktionen vorhanden:
  1023.  
  1024. !subsubtoc [html, stg]
  1025.  
  1026. #*****************************************************************
  1027. !subsubnode DATE
  1028. CONST DATE
  1029.  
  1030. Diese Konstante besitzt (beim Compilieren) als Wert das aktuelle Datum.
  1031. Die Konstante ist vom Typ LONGCARD; der Wert setzt sich wie folgt zusammen:
  1032. !begin_verbatim
  1033.         tDate = RECORD
  1034.             day: [0..31];
  1035.             month: [1..12];
  1036.             year: SHORTINT;
  1037.         END;
  1038. !end_verbatim
  1039.  
  1040. #*****************************************************************
  1041. !subsubnode FLAG
  1042. CONST FLAG
  1043.  
  1044.     Diese Konstante besitzt den Wert der Makevariable FLAG. Mit ihrer Hilfe 
  1045.     kann man von außen auf den Quelltext Einfluß zu nehmen (z.B. um 
  1046.     verschiedene Versionen eines Programmes zu erzeugen, vgl. 
  1047.     [Bedingte_Compilierung]).
  1048.  
  1049. #*****************************************************************
  1050. !subsubnode LINE
  1051. CONST LINE
  1052.  
  1053. Diese Konstante besitzt während des Compilierens als Wert jeweils die 
  1054. aktuelle Zeilennummer. Damit kann man sich in (Debug-) Ausgaben auf eine 
  1055. Zeile des Quelltextes beziehen.
  1056.  
  1057. #*****************************************************************
  1058. !subsubnode ADDRESS
  1059. TYPE ADDRESS
  1060.  
  1061. Dieser Typ ist als POINTER auf den Typ WORD definiert. Das    besondere
  1062. Merkmal ist seine Kompatibilität mit dem Typ CARDINAL und allen anderen
  1063. Typen der Form POINTER TO. Adreßberechnungen sind somit auf Werten dieses
  1064. Typs möglich.
  1065.  
  1066. #*****************************************************************
  1067. !subsubnode LOC
  1068. TYPE LOC 
  1069.  
  1070. Dieser Typ repräsentiert die kleinste adressierbare Speichereinheit.
  1071.  
  1072. !label BITSPERLOC
  1073. CONST BITSPERLOC = 8 
  1074.  
  1075. !label LOCSPERBYTE
  1076. CONST LOCSPERBYTE = 1
  1077.  
  1078. !label LOCSPERWORD
  1079. CONST LOCSPERWORD = 2
  1080.  
  1081. TYPE BYTE = LOC
  1082.  
  1083. Dieser Typ hat eine Größe von einem Byte. Erlaubt ist nur die Zuweisung. 
  1084. Parametern vom Typ BYTE können beliebige Typen mit einer Größe von einem 
  1085. Byte übergeben werden. Definiert man einen Parameter als ARRAY OF BYTE, so 
  1086. können diesem Parameter Variablen beliebigen Typs übergeben werden.
  1087.  
  1088. #*****************************************************************
  1089. !subsubnode WORD
  1090. TYPE WORD
  1091.  
  1092. Dieser Typ hat eine Größe von zwei Bytes. Erlaubt ist nur die Zuweisung. 
  1093. Parametern vom Typ WORD können beliebige Typen mit einer Größe von zwei 
  1094. Bytes übergeben werden.
  1095.  
  1096. #*****************************************************************
  1097. !subsubnode LONG
  1098. TYPE LONG
  1099.  
  1100. Dieser Typ hat eine Größe von vier Bytes. Erlaubt ist nur die Zuweisung. 
  1101. Parametern vom Typ LONG können beliebige Typen mit einer Größe von vier 
  1102. Bytes übergeben werden.
  1103.  
  1104. #*****************************************************************
  1105. !subsubnode SHIFT
  1106. PROCEDURE SHIFT (set: SetType; num: LONGINT): SetType; 
  1107.  
  1108. Diese Funktion liefert als Ergebnis eine Menge, deren Elemente die von 
  1109. 'set' jeweils erhöht um 'num' sind.
  1110.  
  1111. Betrachtet man 'set' als Bitmuster, so wirkt SHIFT als logische 
  1112. Verschiebung nach links oder rechts um ABS (num) Positionen; für 'num' > 0 
  1113. wird nach links geschoben, sonst nach rechts.
  1114.  
  1115. #*****************************************************************
  1116. !subsubnode ROTATE
  1117. PROCEDURE ROTATE (set: SetType; num: LONGINT): SetType; 
  1118.  
  1119. Betrachtet man 'set' als Bitmuster, so wirkt ROTATE als Rotation nach 
  1120. links oder rechts um ABS (num) Positionen; für 'num' > 0 
  1121. wird nach links rotiert, sonst nach rechts.
  1122.  
  1123. #*****************************************************************
  1124. !subsubnode MAKEADR
  1125. PROCEDURE MAKEADR (val: Type): ADDRESS; 
  1126.  
  1127. Diese Funktion wandelt einen Wert in eine Adresse. 
  1128.  
  1129. #*****************************************************************
  1130. !subsubnode ADDADR
  1131. PROCEDURE ADDADR (addr: ADDRESS; offset: LONGINT): ADDRESS; 
  1132.  
  1133. Diese Funktion liefert die Adresse, die bei Addition des Offsets 'offset' 
  1134. zur Adresse 'addr' entsteht.
  1135.  
  1136. #*****************************************************************
  1137. !subsubnode SUBADR
  1138. PROCEDURE SUBADR (addr: ADDRESS; offset: LONGINT): ADDRESS;
  1139.  
  1140. Diese Funktion liefert die Adresse, die bei Subtraktion des Offsets 'offset' 
  1141. zur Adresse 'addr' entsteht.
  1142.  
  1143. #*****************************************************************
  1144. !subsubnode DIFADR
  1145. PROCEDURE DIFADR (addr1, addr2: ADDRESS): LONGINT;
  1146.  
  1147. Diese Funktion liefert die Differenz zweier Adressen. 
  1148.  
  1149. #*****************************************************************
  1150. !subsubnode TSIZE
  1151. PROCEDURE TSIZE (x): LONGCARD;
  1152.  
  1153. Diese Funktion erwartet einen Typnamen als Parameter und liefert dessen 
  1154. Größe in Byte zurück. Strukturierte Typen besitzen immer eine gerade Größe.
  1155. (vgl. SIZE)
  1156.  
  1157. #*****************************************************************
  1158. !subsubnode CAST
  1159. CAST (Type, x)
  1160.  
  1161. Diese Prozedur führt eine Typerzwingung durch. CAST (Type, x) ist identisch 
  1162. mit Type (x). x erhält Type als Typ. Eine Typerzwingung ist nur für 
  1163. Typen gleicher Größe möglich. (vgl. Typerzwingung)
  1164.  
  1165. #*****************************************************************
  1166. !subsubnode CODE
  1167. PROCEDURE CODE(c1, c2, ... , cn);
  1168.  
  1169. Diese Prozedur akzeptiert beliebig viele Parameter. Es dürfen nur 
  1170. Konstanten übergeben werden, die der Reihe nach in die Instruktions-Sequenz 
  1171. eingefügt werden. Für jeden Parameter wird ein Wort (16 Bit) eingesetzt. 
  1172. Die eingesetzten Konstanten werden ggf. als Instruktionen vom Prozessor 
  1173. verarbeitet. Daher ist größte Sorgfalt anzuwenden.
  1174.  
  1175. #*****************************************************************
  1176. !subsubnode LOAD
  1177. PROCEDURE LOAD (x: LONGINT; reg: SHORTCARD);
  1178.  
  1179. Diese Prozedur lädt den Wert des ersten Parameters in das angegebene 
  1180. CPU-Register. Dabei haben die Register folgende Nummern:
  1181.                         
  1182. !begin_verbatim
  1183.     D0 | D1 | D2 | D3 | D4 | D5 | D6 | D7
  1184.  ---------------------------------------
  1185.     0  | 1    | 2  |    3 |  4 |    5 |  6 |    7
  1186.  
  1187.     A0 | A1 | A2 | A3 | A4 | A5 | A6 | A7
  1188.  --------------------------------------- 
  1189.      8 |    9 | 10 | 11 | 12 | 13 | 14 | 15
  1190. !end_verbatim
  1191.  
  1192. Sofern es sich bei dem Register nicht um ein Scratchregister handelt, so 
  1193. wird es im Prozedurprolog automatisch gerettet und im Prozedurepilog 
  1194. restauriert.
  1195.  
  1196. #*****************************************************************
  1197. !subsubnode STORE
  1198. PROCEDURE STORE (reg: SHORTCARD; VAR x: LONGINT);
  1199.  
  1200. Diese Prozedur schreibt den Inhalt des angegebenen CPU-Registers in die 
  1201. übergebene Variable (vgl. LOAD).
  1202.  
  1203. #*****************************************************************
  1204. !subsubnode ADR
  1205. PROCEDURE ADR (x): ADDRESS;
  1206.  
  1207. Diese Funktion akzeptiert einen Parameter, der adressierbar sein muß. Sie 
  1208. liefert die Adresse des Objektes zurück.
  1209.  
  1210. NB: Konstanten sind normalerweise nicht adressierbar. Insbesondere kann man 
  1211. mittels ADR nicht die Adresse einer Prozedur ermitteln. Die Adresse einer 
  1212. Prozedur kann mittels ADDRESSS (ProcName) ermittelt werden (also durch 
  1213. Typerzwingung).
  1214.  
  1215. Unter HM2 kann mittels ADR auch die Adresse 'großer' Konstanten ermittelt 
  1216. werden.
  1217.  
  1218. #*****************************************************************
  1219. !subsubnode NEWPROCESS
  1220. PROCEDURE NEWPROCESS (P: PROC; A: ADDRESS; n: LONGCARD; VAR p: ADDRESS);
  1221.  
  1222. Diese Prozedur erzeugt aus einer Prozedur eine Coroutine. Dazu wird am 
  1223. unteren Ende des Stacks ein Prozeßblock angelegt. 'P' wird eine 
  1224. parameterlose Prozedur übergeben. Über den Parameter 'A' wird eine 
  1225. Speicherbereich der Größe 'n' zur Verfügung gestellt. In 'p' erhält man 
  1226. einen Zeiger auf die Coroutine. Coroutinen dürfen nie ihr Ende erreichen!
  1227.  
  1228. #*****************************************************************
  1229. !subsubnode TRANSFER
  1230. PROCEDURE TRANSFER (VAR p1, p2: ADDRESS);
  1231.  
  1232. Um die Kontrolle von einer Coroutine 'p1' auf einen andere Coroutine 'p2' 
  1233. übertragen, verwendet man die Prozedur TRANSFER.
  1234.  
  1235. #*****************************************************************
  1236. !subsubnode IOTRANSFER
  1237. PROCEDURE IOTRANSFER (VAR p1, p2: ADDRESS; v: LONGCARD);
  1238.  
  1239. Die Programmkontrolle wird über einen Interrupt auf eine bestimmte 
  1240. Coroutine übertragen. Bei Aufruf von IOTRANSFER wird in 'p1' die gerade 
  1241. aktive Coroutine gespeichert und die Kontrolle an die in Coroutine 'p2' 
  1242. transferiert. Über 'v' wird der auslösende Interrupt festgelegt (0-255). 
  1243. Wenn dieser zum nächsten Mal auftritt, so wird die aktuelle Coroutine 
  1244. suspendiert, diese in 'p2' gespeichert und die Coroutine in 'p1' aktiviert. 
  1245. Dies entspricht im wesentlichen dem Aufruf einer Coroutine über TRANSFER. 
  1246. Der Interrupt bewirkt also nur die Einfügung einer TRANSFER- Anweisung in 
  1247. den Programmablauf.
  1248.  
  1249. #*****************************************************************
  1250. !subnode FPU
  1251.  
  1252. Bei dem Modul FPU handelt es sich ebenso wie bei dem Modul SYSTEM um ein 
  1253. Pseudo-Modul. Dieses Modul ist jedoch nur bei aktivierter 
  1254. Compiler-Option <f> (Coprozessor) vorhanden. Es stellt die nachfolgend 
  1255. aufgeführten Funktionen des mathematischen Coprozessors MC68881/882 zur 
  1256. Verfügung. Bei Verwendung dieser Prozeduren wird Code erzeugt, der die 
  1257. entsprechenden Coprozessor-Funktionen direkt verwendet. 
  1258.  
  1259. !label PI
  1260. !label E
  1261. !label LN_2
  1262. !label LN_10
  1263. !label LOG2_E
  1264. !label LOG10_E
  1265. !label LOG10_2
  1266. !label EXTENDED
  1267. !label SIN
  1268. !label SINH
  1269. !label ASIN
  1270. !label COS
  1271. !label COSH
  1272. !label ACOS
  1273. !label TAN
  1274. !label TANH
  1275. !label ATAN
  1276. !label SQRT
  1277. !label ETOX
  1278. !label ETOXM1
  1279. !label TWOTOX
  1280. !label TENTOX
  1281. !label LOGN
  1282. !label LOGNP1
  1283. !label LOG10
  1284. !label LOG2
  1285. !begin_verbatim
  1286. CONST 
  1287.     PI            (* π *) 
  1288.     E             (* e *) 
  1289.     LN_2        (* natürlicher Logarithmus von 2 *) 
  1290.     LN_10     (* natürlicher Logarithmus von 10 *) 
  1291.     LOG2_E    (* Zweierlogarithmus von e *) 
  1292.     LOG10_E (* Zehnerlogarithmus von e *) 
  1293.     LOG10_2 (* Zehnerlogarithmus von 2 *) 
  1294. !end_verbatim
  1295.  
  1296. TYPE EXTENDED (* extended precision, kompatibel mit SHORTREAL und 
  1297.                                  LONGREAL *) 
  1298.  
  1299. PROCEDURE SIN (x: EXTENDED): EXTENDED;
  1300.     (* sin x *) 
  1301.  
  1302. PROCEDURE SINH (x: EXTENDED): EXTENDED;
  1303.     (* sinh x *) 
  1304.  
  1305. PROCEDURE ASIN (x: EXTENDED): EXTENDED;
  1306.     (* arc sin x *) 
  1307.  
  1308. PROCEDURE COS (x: EXTENDED): EXTENDED;
  1309.     (* cos x *) 
  1310.  
  1311. PROCEDURE COSH (x: EXTENDED): EXTENDED;
  1312.     (* cosh x *) 
  1313.  
  1314. PROCEDURE ACOS (x: EXTENDED): EXTENDED;
  1315.     (* arc cos x *) 
  1316.  
  1317. PROCEDURE TAN (x: EXTENDED): EXTENDED;
  1318.     (* tan x *)
  1319.  
  1320. PROCEDURE TANH (x: EXTENDED): EXTENDED;
  1321.     (* tanh x *) 
  1322.  
  1323. PROCEDURE ATAN (x: EXTENDED): EXTENDED;
  1324.     (* arc tan x *) 
  1325.  
  1326. PROCEDURE ATANH (x: EXTENDED): EXTENDED;
  1327.     (* arc tanh x *) 
  1328.  
  1329. PROCEDURE SQRT (x: EXTENDED): EXTENDED;
  1330.     (* Quadratwurzel x *) 
  1331.  
  1332. PROCEDURE ETOX (x: EXTENDED): EXTENDED;
  1333.     (* e hoch x *) 
  1334.  
  1335. PROCEDURE ETOXM1 (x: EXTENDED): EXTENDED;
  1336.     (* (e hoch x) minus 1 *) 
  1337.  
  1338. PROCEDURE TWOTOX (x: EXTENDED): EXTENDED;
  1339.     (* 2 hoch x *) 
  1340.  
  1341. PROCEDURE TENTOX (x: EXTENDED): EXTENDED;
  1342.     (* 10 hoch x *) 
  1343.  
  1344. PROCEDURE LOGN (x: EXTENDED): EXTENDED;
  1345.     (* ln x *) 
  1346.  
  1347. PROCEDURE LOGNP1 (x: EXTENDED): EXTENDED;
  1348.     (* ln (x + 1) *) 
  1349.  
  1350. PROCEDURE LOG10 (x: EXTENDED): EXTENDED;
  1351.     (* Logarithmus Basis 10 *) 
  1352.  
  1353. PROCEDURE LOG2 (x: EXTENDED): EXTENDED;
  1354.     (* Logarithmus Basis 2 *) 
  1355.  
  1356. Neben diesen Funktionen, die namentlich denen des mathematischen 
  1357. Coprozessors entsprechen, gibt es noch die beiden folgenden Funktionen 
  1358. zum Umwandeln von ganzen Zahlen in Fließkommazahlen und umgekehrt. Für 
  1359. die Umwandlung wird die MOVE-Instruktion des mathematischen Coprozessors 
  1360. benutzt. Die Rundung ist also abhängig von der eingestellten Rundung des 
  1361. mathematischen Coprozessors.
  1362.  
  1363. !label EXTEND
  1364. PROCEDURE EXTEND (x: LONGINT): EXTENDED;
  1365.  
  1366. !label WHOLE
  1367. PROCEDURE WHOLE (x: EXTENDED): LONGINT;
  1368.  
  1369. #*****************************************************************
  1370. !subnode Registerbelegung
  1371.  
  1372. Die Register D0, D1, A0, A1 und FP0 werden als sogenannte Scratchregister
  1373. behandelt, d.h. sie müssen in Prozeduren nicht gerettet werden. Alle 
  1374. anderen Register werden bei Verwendung in einer Prozedur im 
  1375. Prozedurprolog gerettet und im Prozedurepilog wieder restauriert.
  1376.  
  1377. Funktionsprozeduren geben ihr Ergebnis in D0 bzw. D0/D1 oder FP0 zurück. 
  1378. Dies gilt für Datentypen mit einer Größe von maximal 4 Bytes und für 
  1379. LONGREALs. Größere Typen werden quasi als Referenzparameter behandelt.
  1380.  
  1381. Die Register D2 - D7, A2 - A4 und FP1 - FP7 stehen für Registervariablen 
  1382. zur Verfügung.
  1383.  
  1384. Das Adreßregister A4 wird ggf. auch für WITH-Anweisungen benutzt.
  1385.  
  1386. Das Adreßregister A5 dient als Basiszeiger für die globalen Variablen 
  1387. des Moduls. Bei Eintritt in eine exportierte Prozedur wird Register A5 
  1388. gerettet und mit der Adresse des Modul-Datenbereiches geladen. In allen 
  1389. anderen, nicht exportierten Prozeduren, ist Register A5 dann bereits 
  1390. definiert und wird daher nicht neu geladen.
  1391.  
  1392. Das Adreßregister A6 dient als Basiszeiger für die lokalen Variablen und 
  1393. die Parameter einer Prozedur. Der Bereich für die lokalen Variablen wird 
  1394. bei Prozedureintritt auf dem Stack angelegt.
  1395.  
  1396. Das Adreßregister A7 dient als Stack-Pointer. Der Stack wächst, wie auf 
  1397. 680x0-Prozessoren üblich, von hohen Adressen in Richtung niedriger 
  1398. Adressen. Bei aktivierter Compiler-Option $S wird beim Prozedureintritt 
  1399. überprüft, ob der für den Stack vorgesehene Bereich noch für den lokalen 
  1400. Datenbereich ausreicht oder ob ein Stacküberlauf eingetreten ist.
  1401.  
  1402. #*****************************************************************
  1403. !subnode Sonstiges
  1404.  
  1405. !subsubtoc [html, stg]
  1406.  
  1407. #*****************************************************************
  1408. !subsubnode Typerzwingung
  1409.  
  1410. Setzt man einen Typnamen vor einen geklammerten Ausdruck, so erhält der 
  1411. Ausdruck diesen Typ. Dabei wird kein Code erzeugt. Die Typerzwingung ist 
  1412. nur dann möglich, wenn die Größe des angegebenen Typs mit der Größe des 
  1413. Typs des Ausdrucks übereinstimmt (vgl. VAL). Die Typerzwingung kann bei 
  1414. HM an allen syntaktisch sinnvollen Stellen eingesetzt werden, auch auf 
  1415. der linken Seite einer Zuweisung oder bei Referenzparametern (vgl. 
  1416. SYSTEM.CAST). Beispiele:
  1417.  
  1418. !begin_verbatim
  1419.         VAR
  1420.             l: LONGINT;
  1421.             b: BITSET;
  1422.             proc: PROC;
  1423.     
  1424.         PROCEDURE p (VAR a: ADDRESS);
  1425.             (* ... *) 
  1426.     
  1427.         b := BITSET(SHORTINT(b)*2);
  1428.         p (ADDRESS(l));
  1429.         ADDRESS(proc) := NIL;
  1430. !end_verbatim
  1431.     
  1432. #*****************************************************************
  1433. !subsubnode Variablen an festen Adressen
  1434.  
  1435. Normalerweise liegen Variablen im Datenbereich des Programms und der 
  1436. Programmierer hat keinen Einfluß auf die Adresse einer Variable im Speicher. 
  1437. Unter HM ist es möglich, eine Variable an eine feste Adresse im Speicher zu 
  1438. legen. Auf diese Weise lassen sich Systemvariablen und Hardware-Register 
  1439. einfach ansprechen:
  1440.  
  1441. !begin_verbatim
  1442.     VAR
  1443.         a[456H], b: LONGINT;
  1444.     BEGIN
  1445.         b := a;
  1446. !end_verbatim
  1447.  
  1448. Das Beispiel zeigt den direkten Zugriff auf das Langwort an Adresse 456H. Die 
  1449. Deklaration einer solchen Variable kann sowohl global als auch lokal in einer 
  1450. Prozedur erfolgen (dies beeinflußt nur den Sichtbarkeitsbereich der 
  1451. Variable). Innerhalb der eckigen Klammern wird ein konstanter Ausdruck 
  1452. erwartet, der die Adresse der Variable festlegt.
  1453.  
  1454. #*****************************************************************
  1455. !subsubnode Rückgabewerte
  1456.  
  1457. Unter HM ist es möglich, daß Prozeduren einen RECORD- oder einen 
  1458. ARRAY-Typ als Rückgabewert besitzen. Funktionen, die Zeiger oder 
  1459. strukturierte Werte zurückgeben, dürfen direkt referenziert werden. So 
  1460. ist z.B. ein Aufruf wie
  1461.  
  1462. !begin_verbatim
  1463.     TYPE
  1464.         tType = POINTER TO Type;
  1465.     VAR
  1466.         t: Type
  1467.     BEGIN
  1468.         t := xxx()^;
  1469. !end_verbatim
  1470.  
  1471. erlaubt, falls die Funktion xxx einen Zeiger auf den entsprechenden
  1472. Datentyp zurückgibt.
  1473.  
  1474. #*****************************************************************
  1475. !subsubnode Konstantendeklaration
  1476.  
  1477. Standardfunktionen, die Konstanten zurückliefern, wie z.B. die Funktion
  1478. TSIZE, dürfen auch in der Deklaration von Konstanten verwendet werden.
  1479. Der in einem konstanten Ausdruck verwendete Typ muß jedoch vorher deklariert
  1480. werden!
  1481.  
  1482. #*****************************************************************
  1483. !subsubnode Konkatenation von String- und Zeichenkonstanten
  1484.  
  1485. HM2 erlaubt die Konkatenation, also das Aneinanderhängen bzw. die 
  1486. Verkettung, von String- und Zeichenkonstanten zu Stringkonstanten. Dazu 
  1487. werden beliebig viele String- und/oder Zeichenkonstanten mittels '+' 
  1488. miteinander verbunden. Beispiel:
  1489.  
  1490. !begin_verbatim
  1491.     CONST
  1492.         cVersion = '1.00';
  1493.         cCR = 15C;
  1494.         cLF = 12C;
  1495.         cNl = cCR + cLF;
  1496.         cMsg = 'Dies ist Version ' + cVersion + cNl;
  1497. !end_verbatim
  1498.  
  1499. #*****************************************************************
  1500. !subsubnode Kontrollstrukturen
  1501.  
  1502. In Schleifen sind die Anweisungen BREAK und CONTINUE erlaubt. BREAK 
  1503. bricht die Schleife ab, während CONTINUE die Berechnung mit dem nächsten 
  1504. Schleifendurchlauf fortsetzt. CONTINUE ist auch in der CASE-Anweisung 
  1505. erlaubt. Die Berechnung wird dann an der nächstliegenden Fallauswahl 
  1506. fortgesetzt.
  1507.  
  1508. #*****************************************************************
  1509. !subnode Kommandozeile
  1510.  
  1511. Die Syntax der Kommandozeile sieht folgendermaßen aus (man erhält sie 
  1512. auch durch den Aufruf "HM -h"):
  1513.  
  1514. !begin_verbatim
  1515.         HM [-bcilnosu] [MakeFile]
  1516.              {[-z [MainModule]] [-v {MakeVar=Value}]}
  1517.              {-r[a] {RemoveModule}}
  1518.              {-p[g] {CheckPath}}
  1519.              {-d {DefModule|DefPath}}
  1520.              {-m {ImpModule|ImpPath}}
  1521. !end_verbatim
  1522.  
  1523.  
  1524. (!B)Direktiven(!b)
  1525.  
  1526. Direktiven sind Schalter, die das Verhalten des Compilers verändern. 
  1527. Nicht verändert wird aber der erzeugte Code.
  1528.  
  1529.  
  1530. !begin_verbatim
  1531.     b - nicht Build durchführen
  1532.     c - nicht linken
  1533.                 (kommt übrigens von *IX: nur C-Compiler -> nicht linken!)
  1534.     i - bei Make-Lesen und -Sichern Dateinamen interaktiv erfragen
  1535.     l - am Ende Liste der Modulzustände ausgeben
  1536.     n - NonStop - bei Fehlern nicht anhalten (für Batchbetrieb)
  1537.     o - jedes 'o' vergrößert Makespeicher um 16 kByte
  1538.                  (nicht in ACC-Version)
  1539.     s - Make-Datei am Ende auch sichern, wenn keine Änderung
  1540.                  festgestellt wird
  1541.     u - TOS: Pfadnamen NICHT in Großbuchstaben konvertieren
  1542.             sonst: Pfadnamen DOCH in Großbuchstaben konvertieren
  1543. !end_verbatim
  1544.  
  1545. !stg @symbol MakeFile
  1546. (!B)MakeFile(!b)
  1547.  
  1548. enthält den Namen der Makedatei. Wird am Dateisuffix 
  1549. erkannt, muß daher in Groß-/Kleinschreibung korrekt sein (unter TOS 
  1550. groß, also ".HM2"!)
  1551.  
  1552.  
  1553. !stg @symbol -z
  1554.  
  1555. (!B)-z (MainModule)(!b) (Choo(!B)Z(!b)e)
  1556.  
  1557. Setzt das Hauptmodul, auf das sich Optionseinstellungen beziehen und aus 
  1558. dem das Hauptprogramm erstellt wird. Ohne Angabe eines Modulnamens ist 
  1559. anschließend kein Hauptmodul aktiv, nachfolgende Optionsangaben setzen 
  1560. die Defaulteinstellungen.
  1561.  
  1562. N.B.: Laut Syntax können (wegen {[-z...] [-v...]}) in einem Aufruf die 
  1563. Optionen für mehrere Hauptmodule gesetzt werden.
  1564.  
  1565.  
  1566. !stg @symbol -v
  1567.  
  1568. (!B)-v {MakeVar=Value}(!b) (Variable)
  1569.  
  1570. Die in der Makedatei angebbaren Variablen können hier umdefiniert werden:
  1571.  
  1572. !begin_verbatim
  1573.         MOPT            Make-Optionen
  1574.         MAIN            Hauptmodul
  1575.  
  1576.         Auf das aktive Hauptmodul beziehen sich:
  1577.  
  1578.         COPT            Compiler-Optionen
  1579.         COMP            Speicher für Compiler
  1580.         FLAG            SYSTEM.FLAG für Compiler
  1581.  
  1582.         LOPT            Linker-Optionen
  1583.         STACK         Stackgröße für gelinktes Programm 
  1584.         LINK            Speicher für Linker
  1585.         EXT             Suffix für gelinktes Programm (samt Punkt, z.B. "EXT=.PRG")
  1586.         PROG            Größe für Programmspeicher beim Linken
  1587.         DEST            Zielsystem (0=TOS, 1=MINIX, 2=RTOS, ...)
  1588.         TOS             TOS-Spezifisches
  1589.         RTOS            RTOS-Spezifisches
  1590. !end_verbatim
  1591.  
  1592.  
  1593. !stg @symbol -r
  1594. (!B)-r[a] {RemoveModule}(!b) (Remove/Archive)
  1595.  
  1596. Entfernt Modul(e) aus dem Make. Mit dem Zusatz a werden bei Objekten in 
  1597. Archiven alle Module in diesem Archiv auf einmal entfernt, also z.B.
  1598. "-ra Terminal" entfernt alle Module aus STD.A.
  1599.  
  1600.  
  1601.  
  1602. !stg @symbol -p
  1603. (!B)-p[g] {CheckPath}(!b) (Path/Generate)
  1604.  
  1605. Meldet Dateien in das Make an. Die Angabe erfolgt über Dateinamen mit 
  1606. oder ohne Wildcards, oder durch mit '\' bzw. '/' abgeschlossene 
  1607. Pfadnamen. Ohne den Zusatz g (generate) werden nur vorhandene Einträge 
  1608. überprüft, mit dem Zusatz g werden auch neue eingetragen.
  1609.  
  1610. Werden keine Pfade angegeben, werden sämtliche dem Make bekannten Pfade 
  1611. neu eingecheckt.
  1612.  
  1613.  
  1614.  
  1615. !stg @symbol -d
  1616. (!B)-d {DefModule|DefPath}(!b) (Definition)
  1617.  
  1618. Übersetzt die DEFINITION MODULEs. Die Angabe kann durch den Modulnamen 
  1619. oder durch den Pfadnamen (bzw. ein Suffix davon) erfolgen. Werden keine 
  1620. Module angegeben, werden alle ungültigen Def.-Module dieses Projekts 
  1621. übersetzt.
  1622.  
  1623.  
  1624.  
  1625. !stg @symbol -m
  1626. (!B)-m {ImpModule|ImpPath}(!b) (imp. Module)
  1627.  
  1628. Übersetzt die IMPLEMENTATION MODULEs. Die Angabe kann durch den 
  1629. Modulnamen oder durch den Pfadnamen (bzw. ein Suffix davon) erfolgen. 
  1630. Werden keine Module angegeben, werden sämtliche Imp.-Module dieses 
  1631. Projekts übersetzt, egal ob gültig oder nicht.
  1632.  
  1633.  
  1634. # Ende des Dokuments.
  1635.